package com.hfut.eeg.service;

import com.hfut.eeg.common.api.CommonResult;
import com.hfut.eeg.common.util.GenerateCommon;
import com.hfut.eeg.common.util.GenerateID;
import com.hfut.eeg.dao.OrdertableMapper;
import com.hfut.eeg.dto.OrderPatientInfo;
import com.hfut.eeg.dto.Ordertable;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.RequestBody;

import java.sql.Date;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/*
* @Auther tjf
* 病人检查预约模块
* 对病人预约进行增删改查操作
* */
@Service
public class OrdertableService implements GenerateID {

    @Autowired
    OrdertableMapper ordertableMapper;

    @Autowired
    private GenerateCommon common;

    @Override
    public String getLatestID() {
        return ordertableMapper.getOrderTableLatestID();
    }

    /*
    * 病人预约
    * */
    public Ordertable insertOrder(Ordertable ordertable){
        ordertableMapper.insertOrder(ordertable);
        return ordertable;
    }
    /*
    * 删除预约
    * */
    public int deleteOrder(String patientId){
        return ordertableMapper.deleteOrder(patientId);
    }
    /*
    * 添加预约病人信息
    * */
    public int insertOrderPatientInfo(OrderPatientInfo orderPatientInfo){
        return ordertableMapper.orderPatientInfo(orderPatientInfo);
    }
    /*
    * 获取预约病人的姓名
    * 传入日期参数
    * 返回一个包含病人姓名的数组给前端
    * */
    public List<List> selectname( ArrayList<String> date, Integer ampm){
        List<List> list1 = new ArrayList<>();
        for (String s: date) {
            java.sql.Date date1 = createDate(s);
            if(ordertableMapper.selectName(date1, ampm)!=null){
                List list = ordertableMapper.selectName(date1, ampm);
                list1.add(list);
            }
        }
        return list1;

    }
    /*
    * 获取每天病人的人数，从而判断该天的预约人数是否已满
    * */
    public List<String> selectcount(Date date){
        return ordertableMapper.selectCount(date);
    }
    /*
    * 获取病人的Id
    * */
    public String selectid(String patientId){
        return ordertableMapper.selectId(patientId);
    }

    /*   Year
     *获取前端传来的时间段，按照年份来查询整年的人数
     *传入的参数是两个日期
     *因为要获取每年的日期，再根据每年获取人数
     *首先获取起始时间，再对日期字符串进行分割
     * 获取年份，再对每年进行加 1 操作，再把字符串拼接成一个日期格式 yyyy-mm-dd
     */
    public List<Map<String, Object>> getCount3(Date date1,Date date2) {
        //把日期类型转为字符串
        String s1 = date1.toString();
        String s2 = date2.toString();
        //对字符串进行分割
        String[] str1 = s1.split("-");
        String[] str2 = s2.split("-");
        List<Map<String, Object>> list = new ArrayList<>();
        //判断当前年份的开始月份，一直查询到12月的人数
        if (Integer.parseInt(str1[0]) < Integer.parseInt(str2[0])) {
            String Year = str1[0];
            Map<String, Object> map = new HashMap<>();
            //用Map来接收数据库查询的map集合
            map = ordertableMapper.count3(Year);
            map.put("date", Year);

            list.add(map);
        }
        //判断中间是否隔有一整年的时间，如果有，则查询该整年的人数
        int year = Integer.parseInt(str1[0]);
        while (year < (Integer.parseInt(str2[0]) - 1)) {
            year++;
            //整型转为字符串
            String y = Integer.toString(year);
            Map<String, Object> map = new HashMap<>();
            map = ordertableMapper.count3(y);
            map.put("date", y);
            list.add(map);
        }
        //判断前端传来的最后一年，查询到该年的人数
        String Year2 = str2[0];
        Map<String, Object> map = new HashMap<>();
        //用Map来接收数据库查询的map集合
        map = ordertableMapper.count3(Year2);
        map.put("date", Year2);
        list.add(map);
        return list;
    }
    /*
     * Month
     *获取前端传来的时间段，按照该时间段查询每个月的人数
     *获取前端传来的时间段，按照月份来查询整月的人数
     *传入的参数是两个日期
     *因为要获取每月的日期，再根据每月获取人数
     *首先获取起始时间，再对日期字符串进行分割
     *获取每年的月份，再对每月进行加 1 操作，再把字符串拼接成一个日期格式 yyyy-mm-dd
    * */
    public List<Map<String, Object>> getCount4(Date date1,Date date2){
        //把日期类型转为字符串
        String s1 = date1.toString();
        String s2 = date2.toString();
        //对字符串进行分割操作
        String[] str1 = s1.split("-");
        String[] str2 = s2.split("-");
        List<Map<String, Object>> list = new ArrayList<>();

        //判断当前年份的开始月份，一直查询到12月的人数
        if(Integer.parseInt(str1[0]) < Integer.parseInt(str2[0])){
            //获取起始日期的年份
            String Year = str1[0];
            int num = Integer.parseInt(str1[1]);
            /*
            * 用while循环，对日期进行判断
            * 对月份进行加一操作，一直查询到该年12月
            * 分别获取每个月的人数，用Map来接收数据库查询的数据
            * */
             while(num <= 12){
                 String ss = Integer.toString(num);
                 Map<String,Object> map = new HashMap<>();
                 //用Map来接收数据库查询的数据
                 map = ordertableMapper.count4(Year,ss);
                 String ss1 = Year+"-"+ss;
                 map.put("date",ss1);
                 list.add(map);
                 num = num+1;
             }
        }
        //判断中间是否隔有一整年的时间，如果有，则查询该整年的每月的人数
        int year = Integer.parseInt(str1[0]);
        /*
        * 用while循环判断中间是否隔有一整年的时间
        * 如果有，获取这一整年的日期
        * 对这一整年的12个月进行查询操作
        * 分别获取每个月的人数，用Map来接收数据库查询的数据
        * */
        while(year < (Integer.parseInt(str2[0])-1)){
            year++;
            String y = Integer.toString(year);
            int num = 1;
            /*
             * 用while循环，对日期进行判断
             * 对月份进行加一操作，一直查询到该年12月
             * 分别获取每个月的人数，用Map来接收数据库查询的数据
             * */
            while(num <= 12){
                String ss = Integer.toString(num);
                Map<String,Object> map = new HashMap<>();
                map = ordertableMapper.count4(y,ss);
                String ss1 = y+"-"+ss;
                map.put("date",ss1);
                list.add(map);
                num++;
            }
        }
        //判断前端传来的最后一年，从该年的一月份，查询到该年的截止月份
        String Year2 = str2[0];
        int m2 = Integer.parseInt(str2[1]);
        int num2 = 1;
        if(Integer.parseInt(str1[0])==Integer.parseInt(str2[0])){
            int m = Integer.parseInt(str1[1]);
            /*
             * 用while循环，对日期进行判断
             * 对月份进行加一操作，一直查询到最后一年的截止月份
             * 分别获取每个月的人数，用Map来接收数据库查询的数据
             * */
            while (m <= m2){
                String ss = Integer.toString(m);
                Map<String,Object> map = new HashMap<>();
                //用Map来接收数据库查询的数据
                map = ordertableMapper.count4(Year2,ss);
                //拼接字符串
                String ss1 = Year2+"-"+ss;
                map.put("date",ss1);
                list.add(map);
                m++;
            }
            return list;
        }else {
            /*
             * 用while循环，对日期进行判断
             * 对月份进行加一操作，一直查询到最后一年的截止月份
             * 分别获取每个月的人数，用Map来接收数据库查询的数据
             * */
            while(num2 <= m2){
                String ss = num2+" ";
                Map<String,Object> map = new HashMap<>();
                //用Map来接收数据库查询的数据
                map = ordertableMapper.count4(Year2,ss);
                //拼接字符串
                String ss1 = Year2+"-"+ss;
                map.put("date",ss1);
                list.add(map);
                num2++;
            }
            return list;
        }

    }
    /*
     * Day
     * 获取前端传来的时间段，按照该时间段查询每天的人数
     *传入的参数是两个日期
     *因为要获取每天的日期，再根据每天获取人数
     *首先获取起始时间，再对日期字符串进行分割
     *获取每天的具体日期，再对每天进行加 1 操作，再把字符串拼接成一个日期格式 yyyy-mm-dd
    * */
     public List<Map<String, Object>> getCount5(Date date1,Date date2){
         //把日期格式转换为String
        String s1 = date1.toString();
        String s2 = date2.toString();
         //把字符串2019-11-30按 "-" 切割
        String[] str1 = s1.split("-");
        String[] str2 = s2.split("-");
        List<Map<String, Object>> list = new ArrayList<>();
        //判断两个时间，是否是同一个年份
         if(Integer.parseInt(str1[0]) == Integer.parseInt(str2[0]) && Integer.parseInt(str1[1]) <= Integer.parseInt(str2[1])){
             String Year = str1[0];
             //把年份字符串转为整型
             int y1 = Integer.parseInt(str1[0]);
             //把月份字符串转为整型
             int m1 = Integer.parseInt(str1[1]);
             //把天数字符串转为整型
             int d1 = Integer.parseInt(str1[2]);
             //判断当前月份是否是同年的同一个月，如果不是，则从前端传来的当前天的日期，查询到该月底
             if(m1 == Integer.parseInt(str2[1])) {
                 //int转换为String
                 String mm = Integer.toString(m1);
                 /*
                  * 用while循环，对日期进行判断
                  * 获取天数，对天数进行加一操作，一直查询到该月的最后一天
                  * 再把年月日，字符串拼接成日期格式：yyyy-mm-dd
                  * 分别获取每天的人数，调用addDate方法，根据日期查询该天的人数，添加该天的日期和人数到map集合中
                  * */
                 while (d1 <= Integer.parseInt(str2[2])) {
                     String dd = Integer.toString(d1);
                     //拼接字符串
                     String s4 = Year + "-" + mm + "-" + dd;
                     //调用createDate方法，创建日期
                     Date date3 = createDate(s4);
                     //调用addDate方法，根据日期查询该天的人数，添加该天的日期和人数到map集合中
                     list.add(addDate(date3));
                     d1++;
                 }
                 return list;
             }
             //当两个日期不是同年的同一月时
             if(m1 < Integer.parseInt(str2[1])) {
                 //int转换为String
                 String mm = Integer.toString(m1);
                 /*
                  * 用while循环，对日期进行判断
                  * 获取天数，对天数进行加一操作，一直查询到该月的最后一天
                  * 再把年月日，字符串拼接成日期格式：yyyy-mm-dd
                  * 分别获取每天的人数，调用addDate方法，根据日期查询该天的人数，添加该天的日期和人数到map集合中
                  * */
                 while (d1 <= getDays(y1, m1)) {
                     String dd = Integer.toString(d1);
                     //拼接字符串
                     String s4 = Year + "-" + mm + "-" + dd;
                     //调用createDate方法，创建日期
                     Date date3 = createDate(s4);
                     //调用addDate方法，根据日期查询该天的人数，添加该天的日期和人数到map集合中
                     list.add(addDate(date3));
                     d1++;
                 }
                 m1++;
             }

            //判断中间是否隔有整月，如果有，则查询该整月每天的人数
             /*
              * 用while循环，对日期进行判断
              * 获取天数，对天数进行加一操作，一直查询到该月的最后一天
              * 再把年月日，字符串拼接成日期格式：yyyy-mm-dd
              * 分别获取每天的人数，调用addDate方法，根据日期查询该天的人数，添加该天的日期和人数到map集合中
              * */
             while(m1 < Integer.parseInt(str2[1])){
                 String mm = Integer.toString(m1);
                 //每月的第一天
                 int i=1;
                 while (i <= getDays(y1, m1)) {
                     String dd = Integer.toString(i);
                     String s4 = Year + "-" + mm + "-" + dd;
                     //调用createDate方法，创建日期
                     Date date3 = createDate(s4);
                     //调用addDate方法，根据日期查询该天的人数，添加该天的日期和人数到map集合中
                     list.add(addDate(date3));
                     i++;
                 }
                 m1++;
             }
             //判断前端传来的截止月份，从该月第一天查询到该月的截止日期。
             int d2 = 1;
             String mm = Integer.toString(Integer.parseInt(str2[1]));
             /*
              * 用while循环，对日期进行判断
              * 获取天数，对天数进行加一操作，一直查询到该月的截止日期
              * 再把年月日，字符串拼接成日期格式：yyyy-mm-dd
              * 分别获取每天的人数，调用addDate方法，根据日期查询该天的人数，添加该天的日期和人数到map集合中
              * */
             while (d2 <= Integer.parseInt(str2[2])) {
                 String dd = Integer.toString(d2);
                 String s4 = Year + "-" + mm + "-" + dd;
                 //调用createDate方法，创建日期
                 Date date3 = createDate(s4);
                 //调用addDate方法，根据日期查询该天的人数，添加该天的日期和人数到map集合中
                 list.add(addDate(date3));
                 d2++;
             }

             return list;
         }

        //判断前端传来的第一个年份是否小于第二个年份
        if(Integer.parseInt(str1[0]) < Integer.parseInt(str2[0])){
            String Year = str1[0];
            //把年份字符串转为整型
            int y1 = Integer.parseInt(str1[0]);
            //把月份字符串转为整型
            int m1 = Integer.parseInt(str1[1]);
            //把天数字符串转为整型
            int d1 = Integer.parseInt(str1[2]);
            //从该月查询到12月，查询每天的人数
            if(m1 <= 12) {
                //从当月的日期开始，查询到月底
                if(m1 == Integer.parseInt(str1[1])) {
                    //String mm = m1 + " ";
                    String mm = Integer.toString(m1);
                    /*
                     * 用while循环，对日期进行判断
                     * 获取天数，对天数进行加一操作，一直查询到该月的最后一天
                     * 再把年月日，字符串拼接成日期格式：yyyy-mm-dd
                     * 分别获取每天的人数，调用addDate方法，根据日期查询该天的人数，添加该天的日期和人数到map集合中
                     * */
                    while (d1 <= getDays(y1, m1)) {
                        String dd = Integer.toString(d1);
                        String s4 = Year + "-" + mm + "-" + dd;
                        //调用createDate方法，创建日期
                        Date date3 = createDate(s4);
                        //调用addDate方法，根据日期查询该天的人数，添加该天的日期和人数到map集合中
                        list.add(addDate(date3));
                        d1++;
                    }
                    m1++;
                }
                //查询整月每天的人数
                while(m1 <= 12){
                    String mm = Integer.toString(m1);
                    int i=1;//每月的第一天
                    while (i <= getDays(y1, m1)) {
                        String dd = Integer.toString(i);
                        String s4 = Year + "-" + mm + "-" + dd;
                        //调用createDate方法，创建日期
                        Date date3 = createDate(s4);
                        //调用addDate方法，根据日期查询该天的人数，添加该天的日期和人数到map集合中
                        list.add(addDate(date3));
                        i++;
                    }
                    m1++;
                }

            }
        }
        //判断中间是否隔有一整年的时间，如果有，则查询该整年的每天的人数
        int y1 = Integer.parseInt(str1[0]);
         /*
          * 用while循环，对日期进行判断
          * 获取年份，对年份进行判断操作
          * 再获取该年的月份，对月份进行判断操作
          * 再获取该月的天数，将年月日拼接日期格式：yyyy-mm-dd
          * 分别获取每天的人数，调用addDate方法，根据日期查询该天的人数，添加该天的日期和人数到map集合中
          * 再对天进行加一操作，查询完该月的天数之后，再对月进行加一操作，月份查询完之后，再对年份加一操作查询
          * */
        while(y1 < (Integer.parseInt(str2[0])-1)){
            y1++;
            String yy = Integer.toString(y1);
            int m1 = 1;
            while(m1 <= 12) {
                int d1 = 1;
                String mm = Integer.toString(m1);
                while (d1 <= getDays(y1, m1)) {
                    String dd = Integer.toString(d1);
                    String s4 = yy + "-" + mm + "-" + dd;
                    //调用createDate方法，创建日期
                    Date date3 = createDate(s4);
                    //调用addDate方法，根据日期查询该天的人数，添加该天的日期和人数到map集合中
                    list.add(addDate(date3));
                    d1++;
                }
                m1++;
            }
        }
         /*
         * 判断前端传来的最后一年
         * 从该年的一月份
         * 查询到该年的截止月份的每天人数
         * */
        String yy2 = str2[0];
        int y2 =  Integer.parseInt(str2[0]);
        int month = Integer.parseInt(str2[1]);
        int m2 = 1;

        //判断是否小于月份，查询整月的人数
         while(m2 < month) {
             int d2 = 1;
             String mm2 = Integer.toString(m2);//int转String类型
             while (d2 <= getDays(y2, m2)) {
                 //String dd2 = d2 + " ";
                 String dd2 = Integer.toString(d2);
                 String s4 = yy2 + "-" + mm2 + "-" + dd2;
                 //调用createDate方法，创建日期
                 Date date3 = createDate(s4);
                 //调用addDate方法，根据日期查询该天的人数，添加该天的日期和人数到map集合中
                 list.add(addDate(date3));
                 d2++;
             }
             m2++;
         }
         /*
         * 判断截止月份
         * 从该月1号查询到该月的截止日期
         * */
         if(m2== month){
             int d3 = 1;
             while (d3 <= Integer.parseInt(str2[2])) {
                 //String dd2 = d2 + " ";
                 String mm2 = Integer.toString(m2);
                 String dd2 = Integer.toString(d3);
                 String s4 = yy2 + "-" + mm2 + "-" + dd2;
                 //调用createDate方法，创建日期
                 Date date3 = createDate(s4);
                 //调用addDate方法，根据日期查询该天的人数，添加该天的日期和人数到map集合中
                 list.add(addDate(date3));
                 d3++;
             }
         }
         return list;
    }
    /*
    * 根据年月获得该月的天数
    * swith操作，获取该月具体的天数
    * */
    public static int getDays(int year, int month) {
        int days = 0;
        boolean isLeapYear = false;
        if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) {
            isLeapYear = true;
        } else {
            isLeapYear = false;
        }
        switch (month) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                days = 31;
                break;
            case 2:
                if (isLeapYear) {
                    days = 29;
                } else {
                    days = 28;
                }
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                days = 30;
                break;
            default:
                System.out.println("error!!!");
                break;
        }
        return days;
    }
    /*
    * 传入日期参数
    * 查询数据并添加该日期到map集合中
    * 返回map集合
    * */
    public Map<String,Object> addDate(Date date3){
        Map<String,Object> map = new HashMap<>();
        map = ordertableMapper.count5(date3);
        String ss1 = date3.toString();
        map.put("date",ss1);
        return map;
    }
    /*
    * 根据传入的字符串，创建日期
    * */
    public Date createDate(String s4){
        DateFormat format1 = new SimpleDateFormat("yyyy-MM-dd");
        java.util.Date date = null;
        java.sql.Date date3 = null;
        try {
            //把字符串2019-11-30转换为日期格式
            date = format1.parse(s4);
            //把java.util.Date date转换为java.sql.Date
            date3 = new java.sql.Date(date.getTime());
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date3;
    }

}
